<!DOCTYPE html>
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  <title>The source code</title>
  <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
  <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
  <style type="text/css">
    .highlight { display: block; background-color: #ddd; }
  </style>
  <script type="text/javascript">
    function highlight() {
      document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
    }
  </script>
</head>
<body onload="prettyPrint(); highlight();">
  <pre class="prettyprint lang-js">var BUI = require(&#39;bui-common&#39;),
  Base = require(&#39;./base&#39;),
  Item = require(&#39;./canvasitem&#39;),
  Util = require(&#39;./util&#39;),
  Raphael = require(&#39;./raphael/index&#39;);

<span id='BUI-Graphic-Shape'>/**
</span> * @class BUI.Graphic.Shape
 * 图形的基类
 * @extends BUI.Graphic.Base
 */
var Shape = function(cfg){
  Shape.superclass.constructor.call(this,cfg);
};

Shape.ATTRS = {
  attrs : {}
}

BUI.extend(Shape,Base);

//获取画布内元素的一些共性方法
BUI.mixin(Shape,[Item]);

BUI.augment(Shape,{
<span id='BUI-Graphic-Shape-property-isShape'>  /**
</span>   * 是否图形
   * @type {Boolean}
   */
  isShape : true,
  
  //渲染shape
  renderUI : function(){

    var _self = this,
      el = _self.get(&#39;el&#39;),
      node,
      cfg,
      attrs;
    if(!el){
      cfg = _self.cfg;
      attrs = _self.parseElCfg(cfg.attrs);
      el = _self.createElement(attrs);
      _self.set(&#39;el&#39;,el);
    }
    node = el.node;
    node.shape = this;
    _self.set(&#39;node&#39;,node);
  },
<span id='BUI-Graphic-Shape-method-createElement'>  /**
</span>   * @private
   */
  createElement : function(attrs){
    var _self = this,
      parent = _self.get(&#39;parent&#39;),
      set = parent.get(&#39;el&#39;).add([attrs]),
      element;
    element = set[0];
    return element;
  },
<span id='BUI-Graphic-Shape-method-parseElCfg'>  /**
</span>   * @protected
   * 格式化初始化配置项
   */
  parseElCfg : function(attrs){
    attrs.type = this.get(&#39;type&#39;);
    return attrs;
  },
<span id='BUI-Graphic-Shape-method-getTotalLength'>  /**
</span>   * 获取图形的整体长度
   * @return {Number} 长度
   */
  getTotalLength : function(){
    return this.get(&#39;el&#39;).getTotalLength();
  },
<span id='BUI-Graphic-Shape-method-rotate'>  /**
</span>   * 旋转
   * @param  {Number} a 旋转的角度
   * @param  {Number} x 旋转的中心点 x
   * @param  {Number} y 旋转的中心点 y
   */
  rotate : function(a, x, y){
    var _self = this;
    if(_self.isGroup){
      if(x == null &amp;&amp; y == null){
        var tpoint = _self._getTranslatePoint();
        x = tpoint.x;
        y = tpoint.y;
      }
    }
    this.get(&#39;el&#39;).rotate(a,x,y);
  },
<span id='BUI-Graphic-Shape-method-scale'>  /**
</span>   * 放大
   * @param  {Number} sx x轴方向的倍数 
   * @param  {Number} sy y轴方向的倍数
   * @param  {Number} cx x轴方向扩展的中心
   * @param  {Number} cy y轴方向扩展的中心
   */
  scale : function(sx, sy, cx,cy){
    var _self = this,
      el = _self.get(&#39;el&#39;);
    
    el.scale(sx, sy, cx,cy);
  },
<span id='BUI-Graphic-Shape-method-transform'>  /**
</span>   * 直接使用transform方法 &lt;br&gt;
   *  &quot;t100,100r30,100,100s2,2,100,100r45s1.5&quot;
   *   - 
   * @param  {String} tstr 几何转换的字符串
   */
  transform : function(tstr){
    var _self = this,
      el = _self.get(&#39;el&#39;);
    el.transform(tstr);
  },
  getBBox : function(){
    return this.get(&#39;el&#39;).getBBox();
  },
<span id='BUI-Graphic-Shape-method-getPath'>  /**
</span>   * 获取路径
   * @return {Array} 路径的数组
   */
  getPath : function(){
    var _self = this,
      el = _self.get(&#39;el&#39;),
      path = el.getPath();
    if(BUI.isString(path)){
      path = Util.parsePathString(path);
    }
    return path;
  },
<span id='BUI-Graphic-Shape-method-getPathString'>  /**
</span>   * 获取路径字符串
   * @return {String} 路径的字符串
   */
  getPathString : function(){
    var _self = this,
      path = _self.getPath();
    return Util.parsePathArray(path);
  },
<span id='BUI-Graphic-Shape-method-getTransformPath'>  /**
</span>   * 获取使用平移后的path
   * @return {Array} 路径的数组
   */
  getTransformPath : function(){
    var _self = this,
      path = _self.getPath(),
      matrix = _self.get(&#39;el&#39;).matrix;
    return Util.transformPath(path,matrix.toTransformString());
  },
  //获取到移动的位置
  _getTranslatePoint : function(){
    var _self = this,
      tPath = _self.getTransformPath(),
      rst = {x : 0,y : 0};
    BUI.each(tPath,function(item){
      if(item[0] == &#39;M&#39;){
        rst.x = item[1];
        rst.y = item[2];
      }
    });
    return rst;
  },
  //获取转换的信息，返回一个数组，处理非数组的场景
  __getTransform : function(value){
    if(BUI.isString(value)){
      value = value.replace(/([t,s,r])/,&#39;;$1 &#39;).split(&#39;;&#39;);
      var temp = [];
      BUI.each(value,function(str){
        if(str){
          var sub = str.split(&#39; &#39;);
          sub = $.map(sub,function(subStr){
            if(BUI.isNumeric(subStr)){
              return parseFloat(subStr);
            }
            return subStr;
          });
          temp.push(sub);
        }
      });
      value = temp;
    }
    return value;
  }
});

<span id='BUI-Graphic-Shape-Circle'>/**
</span> * 圆
 * @class BUI.Graphic.Shape.Circle
 * @extends BUI.Graphic.Shape
 */
var Circle = function(cfg){
  Circle.superclass.constructor.call(this,cfg);
};

Circle.ATTRS = {
<span id='BUI-Graphic-Shape-Circle-property-cx'>  /**
</span>   * 圆心的x坐标
   * @type {Number}
   */
  cx : {},
<span id='BUI-Graphic-Shape-Circle-property-cy'>  /**
</span>   * 圆心的y坐标
   * @type {Number}
   */
  cy : {},
<span id='BUI-Graphic-Shape-Circle-property-r'>  /**
</span>   * 圆的半径
   * @type {Number}
   */
  r : {}
};

BUI.extend(Circle,Shape);

Shape.Circle = Circle;

<span id='BUI-Graphic-Shape-Rect'>/**
</span> * 矩形
 * @class BUI.Graphic.Shape.Rect
 * @extends BUI.Graphic.Shape
 */
var Rect = function(cfg){
  Rect.superclass.constructor.call(this,cfg);
};

Rect.ATTRS = {
<span id='BUI-Graphic-Shape-Rect-property-x'>  /**
</span>   * 矩形的左定点x坐标
   * @type {Number}
   */
  x : {},
<span id='BUI-Graphic-Shape-Rect-property-y'>  /**
</span>   * 矩形的左定点y坐标
   * @type {Number}
   */
  y : {},
<span id='BUI-Graphic-Shape-Rect-property-width'>  /**
</span>   * 矩形的宽度
   * @type {Number}
   */
  width : {},
<span id='BUI-Graphic-Shape-Rect-property-height'>  /**
</span>   * 矩形的高度
   * @type {Number}
   */
  height : {},
<span id='BUI-Graphic-Shape-Rect-property-r'>  /**
</span>   * 圆角
   * @type {Number}
   */
  r: {
    value : 0
  }
};

BUI.extend(Rect,Shape);
Shape.Rect = Rect;

<span id='BUI-Graphic-Shape-Ellipse'>/**
</span> * 矩形
 * @class BUI.Graphic.Shape.Ellipse
 * @extends BUI.Graphic.Shape
 */
var Ellipse = function(cfg){
  Ellipse.superclass.constructor.call(this,cfg);
};

Ellipse.ATTRS = {
<span id='BUI-Graphic-Shape-Ellipse-property-cx'>  /**
</span>   * 矩形的左定点x坐标
   * @type {Number}
   */
  cx : {},
<span id='BUI-Graphic-Shape-Ellipse-property-cy'>  /**
</span>   * 矩形的左定点y坐标
   * @type {Number}
   */
  cy : {},
<span id='BUI-Graphic-Shape-Ellipse-property-rx'>  /**
</span>   * 矩形的宽度
   * @type {Number}
   */
  rx : {},
<span id='BUI-Graphic-Shape-Ellipse-property-ry'>  /**
</span>   * 矩形的高度
   * @type {Number}
   */
  ry : {}
};

BUI.extend(Ellipse,Shape);
Shape.Ellipse = Ellipse;

<span id='BUI-Graphic-Shape-Path'>/**
</span> * 路径
 * @class BUI.Graphic.Shape.Path
 * @extends BUI.Graphic.Shape
 */
var Path = function(cfg){
  Path.superclass.constructor.call(this,cfg);
};

Path.ATTRS = {
<span id='BUI-Graphic-Shape-Path-property-path'>  /**
</span>   * 路径
   * @type {String}
   */
  path : {}
};


BUI.extend(Path,Shape);

Shape.Path = Path;

<span id='BUI-Graphic-Shape-Line'>/**
</span> * 直线
 * @class BUI.Graphic.Shape.Line
 * @extends BUI.Graphic.Shape.Path
 */
var Line = function(cfg){
  Line.superclass.constructor.call(this,cfg);
};

Line.ATTRS = {
<span id='BUI-Graphic-Shape-Line-property-x1'>  /**
</span>   * 起始x坐标
   * @type {Number}
   */
  x1 : {},
<span id='BUI-Graphic-Shape-Line-property-y1'>  /**
</span>   * 起始y坐标
   * @type {Number}
   */
  y1 : {},
<span id='BUI-Graphic-Shape-Line-property-x2'>  /**
</span>   * 终止x坐标
   * @type {Number}
   */
  x2 : {},
<span id='BUI-Graphic-Shape-Line-property-y2'>  /**
</span>   * 终止y坐标
   * @type {Number}
   */
  y2 : {}
};

BUI.extend(Line,Path);

BUI.augment(Line,{
<span id='BUI-Graphic-Shape-Line-method-parseElCfg'>  /**
</span>   * @protected
   * 格式化初始化配置项
   */
  parseElCfg : function(attrs){
    attrs.type = &#39;path&#39;; //将线转换成path
    attrs.path = BUI.substitute(&#39;M {x1},{y1}L{x2},{y2}&#39;,attrs);
    return attrs;
  },
  //获取线的坐标点
  _getLinePoint : function(pointIndex,coordIndex){
    var path = this.getPath();
    return path[pointIndex][coordIndex];
  },
  //设置线的坐标点
  _setLinePoint : function(pointIndex,coordIndex,value){
    var _self = this,
      path = this.getPath();
    path[pointIndex][coordIndex] = value;
    _self.attr(&#39;path&#39;,path);
  },
  //设置坐标x1
  __setX1 : function(value){
    this._setLinePoint(0,1,value);
  },
  __getX1 : function(){
    return this._getLinePoint(0,1);
  },
  //设置坐标x2
  __setX2 : function(value){
    this._setLinePoint(1,1,value);
  },
  __getX2 : function(){
    return this._getLinePoint(1,1);
  },
  //设置坐标y1
  __setY1 : function(value){
    this._setLinePoint(0,2,value);
  },
  __getY1 : function(){
    return this._getLinePoint(0,2);
  },
  //设置坐标y2
  __setY2 : function(value){
    this._setLinePoint(1,2,value);
  },
  __getY2 : function(){
    return this._getLinePoint(1,2);
  }
});

Shape.Line = Line;


function points2path(points,z){
  if(BUI.isArray(points)){
    points = points.join(&#39; &#39;);
  }
  return &#39;M&#39; + points + z;
}

<span id='BUI-Graphic-Shape-PolyLine'>/**
</span> * 折线，polyLine
 * @class BUI.Graphic.Shape.PolyLine
 * @extends BUI.Graphic.Shape.Path
 */
var PolyLine = function(cfg){
  PolyLine.superclass.constructor.call(this,cfg);
};

PolyLine.ATTRS = {
<span id='BUI-Graphic-Shape-PolyLine-property-points'>  /**
</span>   * 定点集合，可以是字符串、或者数组
   *
   *  - 字符串： &#39;0,0 25,25 31,50&#39;
   *  - 数组 ： [&#39;0,0&#39;,&#39;25,25&#39;,&#39;31,50&#39;]
   *  
   * @type {Array|String}
   */
  points : {}
};

BUI.extend(PolyLine,Path);

BUI.augment(PolyLine,{
  //设置顶点
  __setPoints : function(value){
    var _self = this,
      el = _self.get(&#39;el&#39;),
      path = points2path(value,&#39;&#39;);
    _self.attr(&#39;path&#39;,path);
  },
<span id='BUI-Graphic-Shape-PolyLine-method-parseElCfg'>  /**
</span>   * @protected
   * 格式化初始化配置项
   */
  parseElCfg : function(attrs){
    attrs.type = &#39;path&#39;; //将线转换成path
    attrs.path = points2path(attrs.points,&#39;&#39;);
    return attrs;
  }

});

Shape.PolyLine = PolyLine;

<span id='BUI-Graphic-Shape-Polygon'>/**
</span> * 多边形
 * @class BUI.Graphic.Shape.Polygon
 * @extends BUI.Graphic.Shape.Path
 */
var Polygon = function(cfg){
  PolyLine.superclass.constructor.call(this,cfg);
};

Polygon.ATTRS = {
<span id='BUI-Graphic-Shape-Polygon-property-points'>  /**
</span>   * 定点集合，可以是字符串、或者数组
   *
   *  - 字符串： &#39;0,0 25,25 31,50&#39;
   *  - 数组 ： [&#39;0,0&#39;,&#39;25,25&#39;,&#39;31,50&#39;]
   *  
   * @type {Array|String}
   */
  points : {}
};

BUI.extend(Polygon,Path);

BUI.augment(Polygon,{
  //设置顶点
  __setPoints : function(value){
    var _self = this,
      el = _self.get(&#39;el&#39;),
      path = points2path(value,&#39;z&#39;);
    _self.attr(&#39;path&#39;,path);
  },
<span id='BUI-Graphic-Shape-Polygon-method-parseElCfg'>  /**
</span>   * @protected
   * 格式化初始化配置项
   */
  parseElCfg : function(attrs){
    attrs.type = &#39;path&#39;; //将线转换成path
    attrs.path = points2path(attrs.points,&#39;z&#39;);
    return attrs;
  }

});

Shape.Polygon = Polygon;

<span id='BUI-Graphic-Shape-Text'>/**
</span> * 文本
 * @class BUI.Graphic.Shape.Text
 * @extends BUI.Graphic.Shape
 */
var Text = function(cfg){
  Text.superclass.constructor.call(this,cfg);
};

Text.ATTRS = {
<span id='BUI-Graphic-Shape-Text-property-x'>  /**
</span>   * x轴坐标
   * @type {Number}
   */
  x : {},
<span id='BUI-Graphic-Shape-Text-property-y'>  /**
</span>   * y轴坐标
   * @type {Number}
   */
  y : {},
<span id='BUI-Graphic-Shape-Text-property-text'>  /**
</span>   * 显示的文本
   * @type {String}
   */
  text : {},
<span id='BUI-Graphic-Shape-Text-property-font'>  /**
</span>   * 字体相关的属性，也可以单独设置其中的属性: font-family,font-weight....
   * @type {String}
   */
  &#39;font&#39; : {},
<span id='BUI-Graphic-Shape-Text-property-text-anchor'>  /**
</span>   * 文本的对齐方式：默认对齐方式: &#39;middle&#39;
   * @type {String}
   */
  &#39;text-anchor&#39; : {}
};

BUI.extend(Text,Shape);

Shape.Text = Text;

<span id='BUI-Graphic-Shape-Label'>/**
</span> * @class BUI.Graphic.Shape.Label
 * 文本标签，继承自文本，但是提供了rotate属性
 * @extends BUI.Graphic.Shape.Text
 */
var Label = function(cfg){
  Label.superclass.constructor.call(this,cfg);
};

BUI.extend(Label,Text);

Label.ATTRS = {
<span id='BUI-Graphic-Shape-Label-property-rotate'>  /**
</span>   * 旋转角度
   * @type {Number}
   */
  rotate : {}
};

BUI.augment(Label,{
<span id='BUI-Graphic-Shape-Label-method-parseElCfg'>  /**
</span>   * @protected
   * 格式化初始化配置项
   */
  parseElCfg : function(attrs){
    attrs.type = &#39;text&#39;;
    if(attrs.rotate){
      attrs.transform = BUI.substitute(&#39;r{rotate} {x} {y}&#39;,attrs);
    }
    
    return attrs;
  }
});

Shape.Label = Label;

<span id='BUI-Graphic-Shape-Marker'>/**
</span> * @class BUI.Graphic.Shape.Marker
 * 用于标示节点的图形
 * @extends BUI.Graphic.Shape
 */
var Marker = function(cfg){
  Marker.superclass.constructor.call(this,cfg);
};

Marker.ATTRS = {
<span id='BUI-Graphic-Shape-Marker-property-symbol'>  /**
</span>   * 类型 &quot;circle&quot;, &quot;square&quot;, &quot;diamond&quot;, &quot;triangle&quot; and &quot;triangle-down&quot;；如果是 &quot;url(xxx)&quot;则是图片；custom则需要指定路径
   * @type {String}
   */
  symbol :{
    value : &#39;custom&#39;
  },
<span id='BUI-Graphic-Shape-Marker-property-radius'>  /**
</span>   * 半径
   * @type {Number}
   */
  radius : {
    value : 5
  },
<span id='BUI-Graphic-Shape-Marker-property-path'>  /**
</span>   * 如果类型为&quot;custom&quot;时指定路径
   * @type {Object}
   */
  path : {

  },
<span id='BUI-Graphic-Shape-Marker-property-x'>  /**
</span>   * 起始x轴位置
   * @type {Number}
   */
  x : {

  },
<span id='BUI-Graphic-Shape-Marker-property-y'>  /**
</span>   * 起始y轴位置
   * @type {Number}
   */
  y : {

  }
};

Marker.Symbols = {
  //圆
  circle : function(x,y,r){
    return [[&#39;M&#39;,x,y - r],[&#39;a&#39;,r,r,0,1,1,0,2*r],[&#39;a&#39;,r,r,0,1,1,0,-2*r],[&#39;z&#39;]];
  },
  //正方形
  square : function(x,y,r){
    return [[&#39;M&#39;,x-r,y-r],[&#39;L&#39;,x + r,y-r],[&#39;L&#39;,x + r,y + r],[&#39;L&#39;,x - r,y + r],[&#39;z&#39;]];
  },
  //菱形
  diamond : function(x,y,r){
    return [[&#39;M&#39;,x - r,y],[&#39;L&#39;,x,y - r],[&#39;L&#39;,x + r, y],[&#39;L&#39;,x,y + r],[&#39;z&#39;]];
  },
  //三角形
  triangle : function(x,y,r){
    var diffX = r / 0.866,
      diffY =  r;
    return [[&#39;M&#39;,x,y-r],[&#39;L&#39;,x + diffX,y + diffY],[&#39;L&#39;,x - diffX, y + diffY],[&#39;z&#39;]];
  },
  //倒三角形
  &#39;triangle-down&#39; : function(x,y,r){
    var diffX = r / 0.866,
      diffY =  r;
    return [[&#39;M&#39;,x,y + r],[&#39;L&#39;,x + diffX, y - diffY],[&#39;L&#39;,x - diffX,y - diffY],[&#39;z&#39;]];
  }
};



BUI.extend(Marker,Shape);

BUI.augment(Marker,{
  //设置半径
  __setRadius : function(v){
    var _self = this,
      attrs = _self.get(&#39;attrs&#39;);

    _self._setSize(attrs.x,attrs.y,v);

  },
  __getRadius : function(){
    return this.get(&#39;attrs&#39;).radius;
  },
  //设置x
  __setX : function(x){
    var _self = this,
      attrs = _self.get(&#39;attrs&#39;);

    _self._setSize(x,attrs.y,attrs.radius);

  },
  __getX : function(){
    return this.get(&#39;attrs&#39;).x;
  },
  //设置y
  __setY : function(y){
    var _self = this,
      attrs = _self.get(&#39;attrs&#39;);

    _self._setSize(attrs.x,y,attrs.radius);

  },
  __getY : function(){
    return this.get(&#39;attrs&#39;).y;
  },
  __getSymbol : function(){
    return this.get(&#39;attrs&#39;).symbol;
  },
  //设置大小，位置
  _setSize : function(x,y,radius){
    var _self = this,
      attrs = _self.get(&#39;attrs&#39;),
      el = _self.get(&#39;el&#39;);
    if(el.type !== &#39;image&#39;){
      var cfg = {
        x : x,
        y : y,
        radius : radius
      };
      BUI.mix(attrs,cfg);
      var path = _self._getPath(attrs);
      el.attr(&#39;path&#39;,path);
    }else{
      BUI.mix(attrs,{
        width : radius * 2,
        height : radius * 2,
        x : x - (radius - attrs.radius),
        y : y - (radius - attrs.radius),
        radius : radius
      });
      el.attr(attrs);
    }
  },
  animate : function(params,ms,easing,callback){
    var _self = this,
      attrs = _self.get(&#39;attrs&#39;),
      path;
        
    if(_self.get(&#39;el&#39;).type == &#39;image&#39;){
      var radius = params.radius || _self.attr(&#39;radius&#39;);
      params.x = params.x - radius;
      params.y = params.y - radius;
      BUI.mix(attrs,{
        x : params.x,
        y : params.y
      });
      _self.get(&#39;el&#39;).animate(params,ms,easing,callback);
    }else{
      BUI.mix(attrs,{
        x : params.x,
        y : params.y
      });
      path = _self._getPath(attrs);
      _self.get(&#39;el&#39;).animate({path : path},ms,easing,callback);
    }
  },

<span id='BUI-Graphic-Shape-Marker-method-parseElCfg'>  /**
</span>   * @protected
   * 格式化初始化配置项
   */
  parseElCfg : function(attrs){
    var _self = this,
      symbol = attrs.symbol,
      radius = attrs.radius || 5;
    if(symbol &amp;&amp; symbol.indexOf(&#39;url&#39;) != -1){ //图片
      attrs.type = &#39;image&#39;;
      attrs.src = symbol.replace(/url\((.*)\)/,&#39;$1&#39;);
      attrs.width = attrs.radius * 2;
      attrs.height = attrs.radius * 2;
      if (Util.vml) {
        attrs.x -= radius-1,
        attrs.y -= radius-1;
      } else {
        attrs.x -= radius,
        attrs.y -= radius;
      }
    }else{
      attrs.type = &#39;path&#39;;
      attrs.path = _self._getPath(attrs);
    }
    return attrs;
  },
  //获取path
  _getPath : function(attrs){
    if(!attrs.symbol &amp;&amp; attrs.path){
      return  BUI.substitute(attrs.path,attrs);
    }
    var method = Marker.Symbols[attrs.symbol];
    if(method){
      return method(attrs.x,attrs.y,attrs.radius)
    }else{
      throw &#39;not support this type &#39; + attrs.symbol;
    }
  }

});

Shape.Marker = Marker;



<span id='BUI-Graphic-Shape-Image'>/**
</span> * @class BUI.Graphic.Shape.Image
 * 图片
 * @extends BUI.Graphic.Shape
 */
var Image = function(cfg){
  Image.superclass.constructor.call(this,cfg);
};

Image.ATTRS = {
<span id='BUI-Graphic-Shape-Image-property-src'>  /**
</span>   * 路径
   * @type {String}
   */
  src : {}, 
<span id='BUI-Graphic-Shape-Image-property-x'>  /**
</span>   * x轴位置
   * @type {Number}
   */
  x : {}, 
<span id='BUI-Graphic-Shape-Image-property-y'>  /**
</span>   * y轴位置
   * @type {Number}
   */
  y : {}, 
<span id='BUI-Graphic-Shape-Image-property-width'>  /**
</span>   * 宽度
   * @type {Number}
   */
  width : {}, 
<span id='BUI-Graphic-Shape-Image-property-height'>  /**
</span>   * 高度
   * @type {Number}
   */
  height : {}
}

BUI.extend(Image,Shape);

Shape.Image = Image;

module.exports = Shape;
</pre>
</body>
</html>
